#!/bin/bash
# Comando "InstalarT"
#Input
#         Archivos de la instalación
#Output
#         Comandos
#         Archivo de Configuración
#         Datos de Prueba
#         Tablas de Parámetros
#         Archivo de Log
#
#Valores de retorno
#	0 Exito
#	1 Perl no esta instalado o su version es menor a la 5.0
#	2 El usuario cancelo la instalación
#	3 Faltan archivos necesarios para la instalacion
#	4 Intento de instalación nueva en sesión de usuario con instancia previa del sistema iniciada
##
###
################## INICIO FUNCIONES ####################
# Loguea y muestra por pantalla
# Parámetros:
#	1-Mensaje
function echoLog() {
	$log I "$1";
	echo "$1";
}

# pregBinaria: Espera una respuesta (Si-No) del usuario, devuelve su respuesta 
# y loguea la pregunta con la respuesta si se pasa el flag correspondiente
# Parámetros:
#	$1 = Pregunta
#	$2 = Flag de log (L = Log)
# Salida: Se guarda (1=afirmativo) o (0=Negativo) en la variable $respPregBinaria
respPregBinaria="";
function pregBinaria() {
	local pregunta=$1;
	local respVal="";
	
	# Mientras la respuesta no sea válida (Si o No)
	while [ -z $respVal ]; do
		# Leo la respuesta y la guardo en $resp
		read -p "$pregunta" resp;
		# Valido que la respuesta sea si o no
		respVal=$(echo $resp | grep '^[Ss][Ii]\{0,1\}$\|^[Nn][Oo]\{0,1\}$');
		if [ -z $respVal ]; then
			echo "Respuesta inválida. Ingrese Si o No";
		fi
	done

	# Paso la respuesta a minuscula
	resp=$(echo $respVal | tr "[:upper:]" "[:lower:]" );

	# Logueo la pregunta con su respuesta si corresponde
	if [ "$#" -eq 2 -a "$2" == "L" ]; then
		$log "I" "$pregunta$resp";
	fi
	
	# Transformo la respuesta a número
	if [ "$resp" == "si" -o "$resp" == "s" ]; then
		respPregBinaria=1;
	else
		respPregBinaria=0;
	fi
}

# crearConfiguracion: Crea el archivo de configurcaion
function crearConfiguracion() {
	$config G GRUPO "$GRUPO";
	$config G ARRIDIR "$ARRIDIR";
	$config G RECHDIR "$RECHDIR";
	$config G BINDIR "$BINDIR";
	$config G MAEDIR "$MAEDIR";
	$config G REPODIR "$REPODIR";
	$config G LOGDIR "$LOGDIR";
	$config G LOGEXT "$LOGEXT";
	$config G LOGSIZE "$LOGSIZE";
	$config G DATASIZE "$DATASIZE";
	for ((i=0;i<10;i++)); do
		$config G "" "";
	done
	$config G CONFDIR "$CONFDIR";
	for ((i=0;i<${#COM_INST[*]};i++)); do
		$config G "COMANDOS" "${COM_INST[$i]}";
	done
	for ((i=0;i<${#ARCH_MAE[*]};i++)); do
		$config G "MAESTROS" "${ARCH_MAE[$i]}";
	done
	for ((i=0;i<${#DIRECTORIOS_RESERVADOS[*]};i++)); do
		$config G "DIRECTORIOS" "${DIRECTORIOS_RESERVADOS[$i]}";
	done
}

# mostrarContenidoDir: Recibe un directorio y devuelve su contenido y el de sus subdirectorios
# Parámetros:
# 	1-Directorio a mostrar
function mostrarContenidoDir() {
	if [ -d "$1" ]; then
		IFSaux=$IFS
		IFS=$'\n'
		for i in `ls -R -1 "$1"`
		do
			IFS=$IFSaux
			echoLog "$i"
			IFS=$'\n'
		done
		IFS=$IFSaux
	else
		echoLog "$1:-";
	fi
}

# mostrarVariablesSistema: Muestra por pantalla y loguea el estado actual de las variables del sistema
function mostrarVariablesSistema() {
		echoLog "$copyright";
		echoLog "";
		echoLog "Directorio de trabajo: $GRUPO";
		echoLog "Librería del Sistema: $CONFDIR";
		echoLog "Directorio de arribo de archivos externos: $ARRIDIR";
		echoLog "Espacio mínimo libre para el arribo de archivos externos: $DATASIZE Mb";
		echoLog "Directorio de grabación de los archivos externos rechazados: $RECHDIR";
		echoLog "Directorio de instalación de los ejecutables: $BINDIR";
		echoLog "Directorio de instalación de los archivos maestros: $MAEDIR";
		echoLog "Directorio de grabación de los logs de auditoria: $LOGDIR";
		echoLog "Extensión para los archivos de log: $LOGEXT";
		echoLog "Tamaño máximo para los archivos de log: $LOGSIZE Kb";
		echoLog "Directorio de grabación de los reportes de salida: $REPODIR";
		echoLog "";
		echoLog "Estado de la instalacion: LISTA";
		echoLog "";
}

# instalarEjecutable
# Copia el script a la carpeta $BINDIR y le asigna permisos de ejecucion
# Parámetros:
#	1 = nombre del script a copiar
function instalarEjecutable() {
	local script=$1;
	# Copio el script a la carpeta de los ejecutables
	cp "$dirInst/$script" "$BINDIR/$script";

	# Si el comando es el IniciarT.sh le modifico la variable $GRUPO
	if [ "$script" = "ConfigT.sh" ]; then
    	sed -i "s:#CONFDIR=\\\"ESTA RUTA LA MODIFICA EL INSTALADOR. NO TOCAR!\\\":CONFDIR=\\\"$CONFDIR\\\":" "$BINDIR/ConfigT.sh"
	fi

	# Asigno permisos de ejecución al script
	chmod u+x "$BINDIR/$script";

	echoLog "$script instalado";
}

# verificarDirReservado
# Permite verificar si el directorio esta reservado
# Parámetros:
# 	1-Directorio a verificar
# Salida:
# 	0-Si el directorio no esta reservado
#	1-Si el directorio ya estaba reservado
function verificarDirReservado() {
	# Verifico que no sea el raiz del sistema
	if [ "$1" == "$GRUPO" ]; then
		return 1;
	fi
	# Verifico que no sea un subdirectorio reservado previamente
	for i in "${DIRECTORIOS_RESERVADOS[@]}"; do
		if [ "$1" == "$i" ]; then
			return 1;
		fi
	done
	return 0;
}

# agregarReservaDir
# Permite agregar una reserva para un directorio
# Parámetros:
#	1-Directorio que quiere reservarse
# Salida: Ninunga
function agregarReservaDir {
	DIRECTORIOS_RESERVADOS=( ${DIRECTORIOS_RESERVADOS[*]} "$1" );
	return 0;
}

# eliminarReservaDir
# Permite eliminar una reserva hecha (si existe) para un directorio
# Parámetros:
#	1-Directorio cuya reserva quiere quitarse
# Salida: Ninunga
function eliminarReservaDir() {
	for ((i = 0 ; i < "${#DIRECTORIOS_RESERVADOS[@]}"; i++)); do
		if [ "${DIRECTORIOS_RESERVADOS[$i]}" == "$1" ]; then
			unset DIRECTORIOS_RESERVADOS["$i"];
			return 0;
		fi
	done
	return 0;
}

# preguntarDirectorio
# Permite el ingreso de un directorio por el usuario y lo valida. A/b/c se permite
# Parámetros:
#	1-Mensaje a mostrar por pantalla
#	2-Directorio por defecto
# Salida:
# 	Si el usuario hace un ingreso, devuelve el directorio en $dirValidado sin las / iniciales o finales
# 	Caso contrarior, devuelve $dirValidado vacio
dirValidado="";
function preguntarDirectorio() {
	local dirIngresado="";
	local resp="";
	local parcial="";
	local defaultDir="$2";
	local preg="$1 ($defaultDir): ";
	local valid=0;
	while [ "$valid" -eq 0 ]; do
		read -p "$preg" dirIngresado;
		# Si el usuario ingreso enter, devuelvo cadena vacia para indicar que se seleccionó el default dir
		if [ -z "$dirIngresado" ]; then
			valid=1;
			resp=""
			$log "I" "$preg$defaultDir";
		else
			# Verifico que contenga caracteres válidos y ninguna / consecutiva
			resp=$(echo $dirIngresado | grep "^[A-Za-z0-9%@_=:./]\{1,\}$" | grep -v "/\{2,\}" );
			# Saco las / iniciales y finales si las tiene
			resp=$(echo $resp | sed -e "s;^/;;" -e "s;/$;;" );
			if [ -z "$resp" ]; then 
				echo -e "\nEl nombre de directorio $dirIngresado es invalido.";
				echo -e "Verifique que contenga solo letras, números o algunos de los siguientes caracteres %@_=:./\n";
			else
				# Agrego la / inicial que le saque previamente para validar
				resp="/$resp"
				# En caso que el path sea parcial, lo completo
				parcial=$(echo $resp | grep "^$GRUPO.*"); 
				# Si no tiene el path de raiz, se lo agrego a la salida
				if [ -z "$parcial" ]; then
					resp="$GRUPO$resp";
				fi
				# Si el subdirectorio ingresado es igual al propuesto por default, salgo
				if [ "$resp" == "$defaultDir" ]; then
					valid=1;
					$log "I" "$preg$resp";
				# Si el directorio solicitado no este reservado, es válido
				elif verificarDirReservado "$resp"; then
					valid=1;
					# Elimino la reserva del directorio viejo y agrego la del nuevo
					eliminarReservaDir "$defaultDir";
					agregarReservaDir "$resp";
					$log "I" "$preg$resp";
				else
					echo -e "\nEl directorio solicitado está reservado. Por favor ingrese otro.\n";
				fi
			fi
		fi
	done
	dirValidado="$resp";
}

# preguntarValorNumerico
# Permite el ingreso por el usuario de un número positivo mayor a cero
# Parámetros:
#	1-Mensaje a mostrar por pantalla
# Salida:
# 	Devuelve el valor ingresado en $rtaNumerica o cadena vacia
rtaNumerica="";
function preguntarValorNumerico(){
	local valIngresado="";
	local resp="";
	local valid=0;
	while [ "$valid" -eq 0 ]; do
		read -p "$1" valIngresado;
		if [ -z "$valIngresado" ]; then
			valid=1;
		else
			# Verifico que contenga caracteres válidos
			resp=$(echo $valIngresado | grep "^[1-9][0-9]\{0,17\}$");
			if [ -z "$resp" ]; then 
				echo "";
				echo "El valor $valIngresado es inválido. Ingrese un número mayor a cero y menor a 999.999.999.999.999.999.";
			else
				valid=1;
			fi
		fi
	done
	rtaNumerica=$resp;
}

# Carga los valores por defecto o ya configurados si lo estuviesen
function cargarValoresDefault() {
	ARRIDIR="$($config L ARRIDIR)";
	if [ -z "$ARRIDIR" ]; then
		ARRIDIR="$GRUPO/arribos";
	fi

	RECHDIR="$($config L RECHDIR)";
	if [ -z "$RECHDIR" ]; then
		RECHDIR="$GRUPO/rechazados";
	fi

	BINDIR="$($config L BINDIR)";
	if [ -z "$BINDIR" ]; then
		BINDIR="$GRUPO/bin";
	fi

	MAEDIR="$($config L MAEDIR)";
	if [ -z "$MAEDIR" ]; then
		MAEDIR="$GRUPO/mae";
	fi

	REPODIR="$($config L REPODIR)";
	if [ -z "$REPODIR" ]; then
		REPODIR="$GRUPO/reportes";
	fi

	LOGDIR="$($config L LOGDIR)";
	if [ -z "$LOGDIR" ]; then
		LOGDIR="$GRUPO/log";
	fi

	LOGEXT="$($config L LOGEXT)";
	if [ -z "$LOGEXT" ]; then
		LOGEXT=".log";
	fi

	export LOGSIZE="$($config L LOGSIZE)";
	if [ -z "$LOGSIZE" ]; then
		LOGSIZE="400";
	fi

	DATASIZE="$($config L DATASIZE)";
	if [ -z "$DATASIZE" ]; then
		DATASIZE="100";
	fi
}

# verificarPerl: Verifica que PERL v5 o superior este instalado. Loguea el proceso
# Parámetros:
# 	1-Número de etapa a loguear en caso de exito
#	2-Número de etapa a loguear en caso de error
# Salida:
# 	0-PERL ok
#	2-PERL no está instalado o la version es inferior a 5
function verificarPerl() {
	# Chequeo la instalacion de PERL
	echoLog "";
	echoLog "$copyright";
	# Obtengo la version y la version mayor de PERL
	PERLV="$(perl -v | grep "v[0-9.]\{1,\}" -o )"; 
	PERLmayorV="$(echo $PERLV | cut -c 2- | cut -f1 -d '.' )"; 

	# Verifico que este instalado y sea mayor o igual a 5 mando
	if [ -z "$PERLV" ] || [ "$PERLmayorV" -lt 5 ]; then
		echoLog "$2";
		echoLog "Para instalar el TP es necesario contar con Perl 5 o superior instalado. Efectúe su instalación e inténtelo nuevamente.";
		echoLog "";
		echoLog "$msgCancel";
		$log E 10;
		return 2;
	else
		echoLog "$1";
		echoLog "PERL Version:$PERLV";
	fi
	return 0;
}

############################# FIN FUNCIONES ################################

################ INICIO DECLARACION Y VALIDACION DE VARIABLES ##############
msgCancel="Proceso de instalación cancelado";
copyright="TP SO7508 1mer cuatrimestre 2012. Tema T Copyright © Grupo 05";

# Verifico que sea un proceso independiente y no hijo
if [ "${BASH_SOURCE[0]}" != "$0" ]; then
	echo "Este comando no esta preparado para correr en modo sourced.";
	echo "Por favor, ejecutelo como proceso independiete anteponiendo ./ al nombre del script.";
    return;
fi

#****Directorios de la instalacion****
GRUPO="$(dirname $(readlink -f $0))";
#GRUPO="${GRUPO%/*}";  # Remuevo el sufijo /inst

# Verifico que contenga caracteres válidos
testRaiz=$(echo $GRUPO | grep "^[A-Za-z0-9%@_=:./]\{1,\}$" );
if [ -z "$testRaiz" ]; then
  echo "Por favor reubique la instalacion en un directorio que contenga solo letras, numeros o alguno de los siguientes caracteres %@_=:./";
  exit 1
fi

# Verifico que el directorio detectado GRUPO exista
if [ ! -d "$GRUPO" ]; then
	# Si hubo un error en la detección, permito el ingreso manualmente
	echo "";
	echo "La autodetección del directorio donde se descomprimió el paquete de instalación ha fallado."
	echo "No se puede iniciar la instalación a menos que lo ingrese manualmente.";
	pregBinaria "Desea ingresarlo manualmente? (Si-No): ";
	if [ $respPregBinaria -eq 0 ]; then
		echo "$msgCancel";
		exit 2;
	else
		dirGrup="";
		while [ -z "$dirGrup" ]; do
			read -p "Ingrese el path completo hasta donde se descomprimio el instalador: " dirGrup;
			if [ -n "$dirGrup" ]; then
				dirGrup="$(echo $dirGrup | sed "s;/$;;" )";
			fi
			if [ ! -d "$dirGrup/inst" ]; then
				echo "Directorio inválido. Intente nuevamente."
				dirGrup="";
			else
				GRUPO="$dirGrup";
			fi
		done
	fi
fi
CONFDIR="$GRUPO/confdir"; #directorio de configuraciones
export CONFDIR;
dirInst="$GRUPO/inst"; #directorio donde se encuentran archivos de la instalacion

#****Archivos y comandos de la instalacion****
declare -a COM_INST; #comandos
declare -a ARCH_INST; #archivos
declare -a ARCH_OBLIGAT #ambos
COM_INST=( "ConfigT.sh" "DetectarT.sh" "GrabarParqueT.sh" "IniciarT.sh" "ListarT.pl" "LoguearT.sh" "MirarT.sh" "MoverT.sh" "StartD.sh" "StopD.sh" );
ARCH_MAE=( "cli.mae" "prod.mae" "sucu.mae" );
ARCH_OBLIGAT=( ${COM_INST[*]} ${ARCH_MAE[*]} );

#****Comandos****
log="$dirInst/LoguearT.sh InstalarT"; # Permite llamar con "log mensaje"
config="$dirInst/ConfigT.sh";

################ FIN DECLARACION DE VARIABLES ###################

####################### INICIO PROGRAMA #########################

# Verifico que existan todos los archivos necesarios para la instalacion 
for i in "${ARCH_OBLIGAT[@]}"; do
	if [ ! -f "$dirInst/$i" ];	then
		# Si el script de login existe, logueo y muestro el error
		if [ -f "$dirInst/LoguearT.sh" ]; then
			chmod u+x "$dirInst/LoguearT.sh";
			echoLog "";
			echoLog "No se encontro el archivo $dirInst/$i necesario para realizar la instalacíon"; 
			echoLog "";
			echoLog "$msgCancel";
			echoLog "Verifique que $i exista";
			echoLog "";
			$log E 2;
			exit 3;
		else
			echo "";
			echo "No se encontro el archivo $dirInst/$i necesario para realizar la instalacíon"; 
			echo "";
			echo "$msgCancel";
			echo "Verifique que $i exista";
			echo "";
			exit 3;
		fi
	fi
done

# Doy permisos de ejecución a los scripts a utilizar durante la instalación
chmod u+x "$dirInst/LoguearT.sh";
chmod u+x "$config";

# Inicializo las variables con los valores default
cargarValoresDefault;

#inicio ejecucion
echoLog "1.";
echoLog "Comando InstalarT - Inicio de Ejecución";

#***Detecto si hay algun componente ya instalado***
$config E;  # Verifico si existe el archivo de configuración
if [ "$?" == "0" ]; then 
#Hay una version instalada. Verifico si esta completa o le faltan componentes
	declare -a COMPONENTES_FALTANTES;
	declare -a COMPONENTES_EXISTENTES;
	for ((i=0;i<${#COM_INST[*]};i++)); do
		if [ ! -x "$BINDIR/${COM_INST[$i]}" ]; then
			# Agrego el nombre del comando al vector de comandos faltantes
			COMPONENTES_FALTANTES=( ${COMPONENTES_FALTANTES[*]} [$i]="${COM_INST[$i]}" );
		else
			# Agrego el nombre del comando al vector de comandos existentes
			COMPONENTES_EXISTENTES=( ${COMPONENTES_EXISTENTES[*]} [$i]="${COM_INST[$i]}" );
		fi
	done

	declare -a MAESTROS_FALTANTES;
	declare -a MAESTROS_EXISTENTES;
	for ((i=0;i<${#ARCH_MAE[*]};i++)); do
		if [ ! -f "$MAEDIR/${ARCH_MAE[$i]}" ]; then
			# Agrego el nombre del comando al vector de comandos faltantes
			MAESTROS_FALTANTES=( ${MAESTROS_FALTANTES[*]} [$i]="${ARCH_MAE[$i]}" );
		else
			# Agrego el nombre del comando al vector de comandos existentes
			MAESTROS_EXISTENTES=( ${MAESTROS_EXISTENTES[*]} [$i]="${ARCH_MAE[$i]}" );
		fi
	done

	# Creo un vector con los directorios a crear
	declare -a DIRECTORIOS_FALTANTES;
	declare -a DIRECTORIOS_EXISTENTES;
	declare -a DIRECTORIOS_NECESARIOS;
	DIRECTORIOS_NECESARIOS=( $ARRIDIR $RECHDIR $BINDIR $MAEDIR $LOGDIR $REPODIR "$GRUPO/inst_recibidas" 
	"$GRUPO/inst_ordenadas" "$GRUPO/inst_rechazadas" "$GRUPO/inst_procesadas" 
	"$GRUPO/parque_instalado" );
	for ((i=0;i<${#DIRECTORIOS_NECESARIOS[*]};i++)); do
		if [ ! -d "${DIRECTORIOS_NECESARIOS[$i]}" ]; then
			# Si el directorio no existe, lo pongo en faltantes
			DIRECTORIOS_FALTANTES=( ${DIRECTORIOS_FALTANTES[*]} [$i]="${DIRECTORIOS_NECESARIOS[$i]}" );
		else
			DIRECTORIOS_EXISTENTES=( ${DIRECTORIOS_EXISTENTES[*]} [$i]="${DIRECTORIOS_NECESARIOS[$i]}" );
		fi
	done
	
	# Verifico si la instalacion esta completa o no segun el flag de faltantes y los directorios faltantes
	if [ "${#COMPONENTES_FALTANTES[*]}" == 0 ] && [ "${#MAESTROS_FALTANTES[*]}" == 0 ] && [ "${#DIRECTORIOS_FALTANTES[*]}" == 0 ]; then
		# INSTALACION COMPLETA
		echoLog "2.1.1.";
		echoLog "$copyright";
		echoLog "";
		echoLog "Librería del Sistema:";
		mostrarContenidoDir "$CONFDIR";
		echoLog "";
		echoLog "Directorio de arribo de archivos externos: $ARRIDIR";
		echoLog "";
		echoLog "Directorio de grabación de los archivos externos rechazados: $RECHDIR";
		echoLog "";
		echoLog "Directorio de instalación de los ejecutables:";
		mostrarContenidoDir "$BINDIR";
		echoLog "";
		echoLog "Directorio de instalación de los archivos maestros:";
		mostrarContenidoDir "$MAEDIR";
		echoLog "";
		echoLog "Directorio de grabación de los logs de auditoria: $LOGDIR";
		echoLog "";
		echoLog "Directorio de grabación de los reportes de salida: $REPODIR";
		echoLog "";
		echoLog "Estado de la instalacion: COMPLETA";
		echoLog "";
		echoLog "$msgCancel";
		exit 0;
	else
		# INSTALACION INCOMPLETA
		echoLog "2.2.1.";
		echoLog "$copyright";
		echoLog "";
		echoLog "Componentes existentes:";
		for i in "${COMPONENTES_EXISTENTES[@]}"; do
			echoLog "Funcionalidad: $i";
		done
		for i in "${MAESTROS_EXISTENTES[@]}"; do
			echoLog "Maestro: $i";
		done
		for i in "${DIRECTORIOS_EXISTENTES[@]}"; do
			echoLog "Directorio: $i";
		done
		echoLog "";
		echoLog "Directorio de instalación de los ejecutables:";
		mostrarContenidoDir "$BINDIR";
		echoLog "";
		echoLog "Directorio de instalación de los archivos maestros:";
		mostrarContenidoDir "$MAEDIR";
		echoLog "";
		echoLog "Componentes faltantes:";
		for j in "${COMPONENTES_FALTANTES[@]}"; do
			echoLog "Binario: $j";
		done
		for j in "${MAESTROS_FALTANTES[@]}"; do
			echoLog "Maestro: $j";
		done
		for j in "${DIRECTORIOS_FALTANTES[@]}"; do
			echoLog "Directorio: $j";
		done
		echoLog "";
		echoLog "Estado de la instalación: INCOMPLETA";
		echoLog "";
		pregBinaria "Desea completar la instalación? (Si-No): " "L";
		if [ $respPregBinaria -eq 0 ]; then
			# El usuario canceló la instalacion
			echoLog "$msgCancel";
			exit 2;
		fi
		
		# Chequeo la instalacion de PERL
		echoLog "";
		echoLog "2.3.1";
		if ! verificarPerl "2.3.1.2" "2.3.1.1"; then
			# No instalado o version inadecuada
			exit 1;
		fi

		# Mustro resumen de configuracion del sistema
		echoLog "";
		echoLog "2.3.2";
		mostrarVariablesSistema;

		# Confirmo inicio de la instalación
		echoLog "2.3.3";
		pregBinaria "Iniciando Instalación. Esta Ud. seguro? (Si-No): " "L";
		if [ $respPregBinaria -eq 0 ]; then
			echoLog "$msgCancel";
			exit 2;
		fi
		
		if [ "${#DIRECTORIOS_FALTANTES[*]}" -gt 0 ]; then
			# Chequeo existencia de directorios
			echoLog "";
			echoLog "2.3.4";
			echoLog "Verificando Estructuras de directorio. . . .";
			
			# Creo los directorios faltantes
			for i in "${DIRECTORIOS_FALTANTES[@]}"; do
				mkdir -p "$i";
				echoLog "Se creo el directorio $i";
			done
		fi

		if [ "${#COMPONENTES_FALTANTES[*]}" -gt 0 ]; then
			# Instalo los programas faltantes
			echoLog "";
			echoLog "2.3.5";
			echoLog "Instalando Programas y Funciones faltantes";
			for k in "${COMPONENTES_FALTANTES[@]}"; do 
				instalarEjecutable "$k";
			done
		fi
		if [ "${#MAESTROS_FALTANTES[*]}" -gt 0 ]; then
			echoLog "";
			echoLog "2.3.6";
			echoLog "Instalando archivos maestros faltantes";
			for k in "${MAESTROS_FALTANTES[@]}"; do 
				cp "$dirInst/$k" "$MAEDIR/$k";
				echoLog "Archivo maestro $k instalado";
			done
		fi
	fi

else #NO HAY NINGUNA INSTALACION ANTERIOR

	# Chequeo que nunca se haya inicializado el sistema en esta sesión
	if [ ! -z "$INICIADO" ]; then
		echo -e "\n*******************************************************************\n"
		echo "ATENCIÓN: Usted está intentando instalar el sistema en una sesión de usuario con datos residuales."
		echo "Por favor, realize la instalación desde una nueva sesión de usuario."
		echo -e "\n*******************************************************************\n"
		exit 4;
	fi

	# Chequeo la instalacion de PERL y aborto la instalación si no cumple con lo pedido
	if ! verificarPerl "3.2" "3.1"; then
		exit 1;
	fi
	
	# Brindo información de la Instalación
	echoLog "";
	echoLog "4.";
	echoLog "Directorio de Trabajo para la instalacion: $GRUPO"
	mostrarContenidoDir "$GRUPO";
	echoLog "";
	echoLog "Librería del Sistema: $CONFDIR";
	mostrarContenidoDir "$CONFDIR";
	echoLog "";
	echoLog "Estado de la instalacion: PENDIENTE";
	echoLog "";
	echoLog "Para completar la instalación Ud. Deberá:";
	echoLog "Definir el directorio de arribo de archivos externos";
	echoLog "Definir el espacio mínimo libre para el arribo de archivos externos";
	echoLog "Definir el directorio de grabación de los archivos externos rechazados";
	echoLog "Definir el directorio de instalación de los ejecutables";
	echoLog "Definir el directorio de instalación de los archivos maestros";
	echoLog "Definir el directorio de grabación de los logs de auditoria";
	echoLog "Definir la extensión y tamaño máximo para los archivos de log";
	echoLog "Definir el directorio de grabación de los reportes de salida";
		
	# Creo un vector con los directorios a reservar
	declare -a DIRECTORIOS_RESERVADOS;
	DIRECTORIOS_RESERVADOS=( $ARRIDIR $RECHDIR $BINDIR $MAEDIR $LOGDIR $REPODIR 
	"$GRUPO/inst_recibidas" "$GRUPO/inst_ordenadas" "$GRUPO/inst_rechazadas" 
	"$GRUPO/inst_procesadas" "$GRUPO/parque_instalado" );

	#ANCLA desde donde vuelvo a arrancar sino esta de acuerdo con la instalacion
	instalar=0;
	while [ "$instalar" -eq 0 ]; do
		echo -e "\nPresione Enter para aceptar valor sugerido entre paréntesis";
		# Defino el directorio de arribo de archivos externos
		echoLog "";
		echoLog "5.";
		msgPregunta="Defina el directorio de arribo de archivos externos";
		preguntarDirectorio "$msgPregunta" "$ARRIDIR";
		if [ -n "$dirValidado" ]; then
			ARRIDIR="$dirValidado";
		fi

		dataSizeValid=0;
		while [ "$dataSizeValid" -eq 0 ]; do
			# Defino el espacio mínimo libre para el arribo de archivos externos
			echoLog "";
			echoLog "6.";
			msgPregunta="Defina el espacio mínimo libre para el arribo de archivos externos en Mbytes ($DATASIZE): ";
			preguntarValorNumerico "$msgPregunta";
			if [ -n "$rtaNumerica" ]; then
				DATASIZE="$rtaNumerica";
			fi
			$log "I" "$msgPregunta$DATASIZE";
	
			# Obtengo el espacio libre del directorio base en Mb de la última linea que devuelve df -BM.
			# Reemplazo los espacios en blanco por ';', saco las "M" y obtengo el campo de espacio libre.
			freeSpace=$(df -BM "$GRUPO" | tail -n1 | sed -e "s/\s\{1,\}/;/g" -e "s/M//g" | cut -f4 -d';' );
			if [ "$freeSpace" -lt "$DATASIZE" ]; then
				echoLog A "";
				echoLog A "7.";
				echoLog A "Insuficiente espacio en disco";
				echoLog A "Espacio disponible: $freeSpace Mb";
				echoLog A "Espacio requerido: $DATASIZE Mb";
				echoLog A "Cancele la instalación e inténtelo más tarde o vuelva a intentarlo con otro valor.";
				pregBinaria "Desea cancelar la instalación? (Si-No): " "L";
				if [ $respPregBinaria -eq 1 ]; then
					echoLog "$msgCancel";
					exit 2;
				fi
				DATASIZE="$freeSpace";
			else
				dataSizeValid=1;
			fi
		done
		
		# Defino el directorio de grabación de los archivos rechazados
		echoLog "";
		echoLog "8.";
		msgPregunta="Defina el directorio de grabación de los archivos externos rechazados";
		preguntarDirectorio "$msgPregunta" "$RECHDIR";
		if [ -n "$dirValidado" ]; then
			RECHDIR="$dirValidado";
		fi
		
		# Defino el directorio de instalación de los ejecutables
		echoLog "";
		echoLog "9.";
		msgPregunta="Defina el directorio de instalación de los ejecutables";
		preguntarDirectorio "$msgPregunta" "$BINDIR";
		if [ -n "$dirValidado" ]; then
			BINDIR="$dirValidado";
		fi

		# Defino el directorio de instalación de los archivos maestros
		echoLog "";
		echoLog "10.";
		msgPregunta="Defina el directorio de instalación de los archivos maestros";
		preguntarDirectorio "$msgPregunta" "$MAEDIR";
		if [ -n "$dirValidado" ]; then
			MAEDIR="$dirValidado";
		fi

		# Defino el directorio de grabación de los logs de auditoria
		echoLog "";
		echoLog "11.";
		msgPregunta="Defina el directorio de grabación de los logs de auditoria";
		preguntarDirectorio "$msgPregunta" "$LOGDIR";
		if [ -n "$dirValidado" ]; then
			LOGDIR="$dirValidado";
		fi

		# Defino la extensión para los archivos de log
		echoLog "";
		echoLog "12.1";
		logExtResp="";
		logExtValid="";
		msgPregunta="Defina la extensión para los archivos de log ($LOGEXT): ";
		while [ -z "$logExtValid" ]; do
			read -p "$msgPregunta" logExtResp;
			if [ -z "$logExtResp" ]; then
				logExtValid="$LOGEXT";
			else
				logExtValid="$(echo "$logExtResp" | grep "^\.[A-Za-z0-9]\{3\}$")";
				if [ -n "$logExtValid" ]; then
					LOGEXT="$logExtValid";
				else
					echo "";
					echo "La extensión ingresada es inválida. Respete el formato .xxx"
				fi
			fi
		done
		$log "I" "$msgPregunta$LOGEXT";

		logSizeValid=0;
		while [ "$logSizeValid" -eq 0 ]; do
			# Definir tamaño máximo para los archivos de log
			echoLog "";
			echoLog "12.2";
			msgPregunta="Defina el tamaño máximo para los archivos $LOGEXT en Kbytes ($LOGSIZE): ";
			preguntarValorNumerico "$msgPregunta";
			if [ -n "$rtaNumerica" ]; then
				LOGSIZE="$rtaNumerica";
			fi
			$log "I" "$msgPregunta$LOGSIZE";

			# Obtengo el espacio libre del directorio base en Kb de la última linea que devuelve df -BK.
			# Reemplazo los espacios en blanco por ';', saco las "K" y obtengo el campo de espacio libre.
			freeSpace=$(df -BK "$GRUPO" | tail -n1 | sed -e "s/\s\{1,\}/;/g" -e "s/K//g" | cut -f4 -d';' );
			if [ "$freeSpace" -lt "$LOGSIZE" ]; then
				echoLog A "";
				echoLog A "12.3";
				echoLog A "Insuficiente espacio en disco";
				echoLog A "Espacio disponible: $freeSpace Kb";
				echoLog A "Espacio requerido: $LOGSIZE Kb";
				echoLog A "Cancele la instalación e inténtelo más tarde o vuelva a intentarlo con otro valor.";
				pregBinaria "Desea cancelar la instalación? (Si-No): " "L";
				if [ $respPregBinaria -eq 1 ]; then
					echoLog "$msgCancel";
					exit 2;
				fi
				LOGSIZE="$freeSpace";
			else
				logSizeValid=1;
			fi
		done

		# Defino el directorio de grabación de los reportes de salida
		echoLog "";
		echoLog "13.";
		msgPregunta="Defina el directorio de grabación de los reportes de salida";
		preguntarDirectorio "$msgPregunta" "$REPODIR";
		if [ -n "$dirValidado" ]; then
			REPODIR="$dirValidado";
		fi

		# Muestro estructura de directorios resultante y valores de parámetros configurados
		echoLog "";
		clear;
		echoLog "14.2";
		mostrarVariablesSistema;
		pregBinaria "Los datos ingresados son correctos? (Si-No): " "L";
		if [ $respPregBinaria -eq 1 ]; then
			# Acepto instalar
			instalar=1;
		else
			clear;
		fi

	done #FIN de preguntas de la instalacion

	# Confirmo inicio de la instalación
	echoLog "";
	echoLog "15";
	pregBinaria "Iniciando Instalación. Esta Ud. seguro? (Si-No): " "L";
	if [ $respPregBinaria -eq 0 ]; then
		echoLog "$msgCancel";
		exit 2;
	fi

	#********COMIENZO A INSTALAR***********
	echoLog "";
	echoLog "16.1";
	echoLog "Creando Estructuras de directorio. . . .";
	
	# Creo los directorios reservados
	for ((i=0;i<${#DIRECTORIOS_RESERVADOS[*]};i++)); do
		# Si el directorio no existe, lo creo
		if [ ! -e "${DIRECTORIOS_RESERVADOS[$i]}" ]; then
			mkdir -p "${DIRECTORIOS_RESERVADOS[$i]}";
			echoLog "Se creo el directorio: ${DIRECTORIOS_RESERVADOS[$i]}";
		else
			echoLog "El directorio ${DIRECTORIOS_RESERVADOS[$i]} ya existe";
		fi
	done
	
	# Copio archivos maestros a $MAEDIR
	echoLog "";
	echoLog "16.2";
	echoLog "Instalando Archivos Maestros";
	for i in "${ARCH_MAE[@]}"; do 
		cp "$dirInst/$i" "$MAEDIR/$i";
		echoLog "Archivo $i instalado";
	done

	# Copio programas y funciones a $BINDIR
	echoLog "";
	echoLog "16.3";
	echoLog "Instalando Programas y Funciones";
	for i in "${COM_INST[@]}"; do 
		instalarEjecutable "$i";
	done
	
	# Actualizo la configuración del sistema
	echoLog "";
	echoLog "16.4";
	echoLog "Actualizando la configuración del sistema";
	crearConfiguracion;

	# Borro archivos temporales

	# Fin de la instalación
	echoLog "";
	echoLog "18.4";
	echoLog "Instalación concluida";

fi

echo "";
echo "Para utilizar el sistema, dirijase a $BINDIR y ejecute \". ./IniciarT.sh\"";
echo "";
exit 0;
